package com.atguigu.encryption.utils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import javax.crypto.KeyGenerator;
import java.security.Key;


/**
 * AES的算法说明
 * 1. 采用的是ECB的加解密方式
 * 2. 密钥长度需要为16/24/32位
 * 3。 默认的位数为128位
 * 4. 返回的密码类型位Base64
 */
public class AESUtil {

    private static final String ALGORITHM = "AES"; // 加密算法
    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding"; // 加密/解密算法-工作模式-填充模式

    /**
     * 生成AES密钥
     *
     * @return 生成的密钥
     * @throws Exception 异常
     */
    private static Key generateKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(128); // 可以选择 128, 192 或 256
        return keyGenerator.generateKey();
    }

    /**
     * AES加密
     *
     * @param data 要加密的字符串
     * @param key  密钥（16字节）
     * @return 加密后的字符串
     * 主力要求加密的密钥至少16位，所以可以采取不足16位自动填充0进行解答
     */
    public static String encrypt(String data, String key) {
        if (key == null || key.length() < 16) {
//            throw new RuntimeException("加密失败，key不能小于16位,，可以为16/24/32");
            key = String.format("%-" + 16 + "s", key).replace(' ', '0'); // 使用0填充到16位
        }
        if (data == null)
            return null;
        try {
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encryptedBytes = cipher.doFinal(data.getBytes());
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * AES解密
     * @param data 要解密的字符串
     * @param key  密钥（16字节）
     * @return 解密后的字符串
     */
    public static String decrypt(String data, String key) {
        if (key == null || key.length() < 16) {
//            throw new RuntimeException("加密失败，key不能小于16位,，可以为16/24/32");
            key = String.format("%-" + 16 + "s", key).replace(' ', '0'); // 使用0填充到16位
        }

        if (data == null)
            return null;
        try {
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(data));
            return new String(decryptedBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        try {
            Key key = generateKey();
            System.out.println("Generated Key: " + key);

            AESUtil aesUtil = new AESUtil();
            String data = "Hello, AES!";
            String keyString = Base64.getEncoder().encodeToString(key.getEncoded());

            // 加密
            String encrypted = aesUtil.encrypt(data, keyString);
            System.out.println("Encrypted: " + encrypted);

            // 解密
            String decrypted = aesUtil.decrypt(encrypted, keyString);
            System.out.println("Decrypted: " + decrypted);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


//import javax.crypto.Cipher;
//import javax.crypto.spec.SecretKeySpec;
//import javax.crypto.spec.IvParameterSpec;
//import java.nio.charset.StandardCharsets;
//import java.security.Key;
//import java.util.Base64;
//import javax.crypto.SecretKeyFactory;
//
//public class AESUtil {
//
//    private static final String ALGORITHM = "AES";
//    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";
//    private static final String CHARSET = "utf-8";
//    private final static String IV_PARAMETER = "1234567812345678"; // 16 bytes IV for AES
//
//    private static Key generateKey(String password) throws Exception {
//        byte[] keyData = password.getBytes(CHARSET);
//        return new SecretKeySpec(keyData, ALGORITHM);
//    }
//
//    /**
//     * AES加密字符串
//     * @param data
//     * @param password
//     * @return
//     */
//    public static String encrypt(String data, String password) {
//        if (password== null || password.length() < 16) {
//            throw new RuntimeException("加密失败，key不能小于16位");
//        }
//        if (data == null)
//            return null;
//        try {
//            Key secretKey = generateKey(password);
//            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
//            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
//            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
//            byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
//            return Base64.getEncoder().encodeToString(encryptedBytes);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//
//    /**
//     * AES解密字符串
//     * @param encryptedData
//     * @param password
//     * @return
//     */
//    public static String decrypt(String encryptedData, String password) {
//        if (password== null || password.length() < 16) {
//            throw new RuntimeException("加密失败，key不能小于16位,，可以为16/24/32");
//        }
//        if (encryptedData == null)
//            return null;
//        try {
//            Key secretKey = generateKey(password);
//            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
//            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
//            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
//            byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
//            return new String(decryptedBytes, StandardCharsets.UTF_8);
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//    }
//}
